import { axios } from '@/utils/request'
import { propertyPage } from '@/api/modular/main/knowl/property/propertyManage'

/**
 * 查询关系管理
 *
 * @author luowen
 * @date 2021-06-03 22:50:57
 */
export function relationPage(parameter) {
  return axios({
    url: '/relation/page',
    method: 'get',
    params: parameter
  })
}

/**
 * 关系管理列表
 *
 * @author luowen
 * @date 2021-06-03 22:50:57
 */
export function relationList(parameter) {
  return axios({
    url: '/relation/list',
    method: 'get',
    params: parameter
  })
}

/**
 * 添加关系管理
 *
 * @author luowen
 * @date 2021-06-03 22:50:57
 */
export function relationAdd(parameter) {
  return axios({
    url: '/relation/add',
    method: 'post',
    data: parameter
  })
}

/**
 * 编辑关系
 *
 * @author luowen
 * @date 2021-06-03 22:50:57
 */
export function relationEdit(parameter) {
  return axios({
    url: '/relation/edit',
    method: 'post',
    data: parameter
  })
}

/**
 * 删除关系管理
 *
 * @author luowen
 * @date 2021-06-03 22:50:57
 */
export function relationDelete(parameter) {
  return axios({
    url: '/relation/delete',
    method: 'post',
    data: parameter
  })
}

/**
 *  限定词列表
 * @param {Object} parameter
 */
export function qualifierList(parameter) {
  return axios({
    url: '/qualifier/list',
    method: 'get',
    params: parameter
  })
}

/**
 *  添加限定词
 * @param {Object} parameter
 */
export function qualifierAdd(parameter) {
  return axios({
    url: '/qualifier/add',
    method: 'post',
    data: parameter
  })
}

/**
 *  限定词左侧穿梭框
 * @param {Object} parameter
 */
export function qualifierSourceList(parameter) {
  return axios({
    url: '/relation/qualifierSourceList',
    method: 'get',
    params: parameter
  })
}

/**
 *  限定词右侧穿梭框
 * @param {Object} parameter
 */
export function qualifierTargetList(parameter) {
  return axios({
    url: '/relation/qualifierTargetList',
    method: 'get',
    params: parameter
  })
}

/**
 * 合并接口
 * @param {Object} parameter
 */
export function qualifierSource(parameter) {
  return Promise.all([qualifierSourceList(parameter), qualifierTargetList(parameter)])
    .then((result) => {
      const source = result[0].data
      const target = result[1].data
      return Promise.resolve({
        source: source || [],
        target: target || []
      })
    })
    .catch((e) => {
      return Promise.reject(e)
    })
}

/**
 * 关系挖掘
 * @param {Object} parameter
 */
export function relationRulePage(parameter) {
  return axios({
    url: '/relationRule/page',
    method: 'get',
    params: parameter
  })
}

/**
 * 关系挖掘-新增
 * @param {Object} parameter
 */
export function relationRuleAdd(parameter) {
  return axios({
    url: '/relationRule/add',
    method: 'post',
    data: parameter
  })
}

/**
 * 关系挖掘-修改
 * @param {Object} parameter
 */
export function relationRuleEdit(parameter) {
  return axios({
    url: '/relationRule/edit',
    method: 'post',
    data: parameter
  })
}

/**
 * 关系挖掘_关系规则_删除
 * @param {Object} parameter
 */
export function relationRuleDelete(parameter) {
  return axios({
    url: '/relationRule/delete',
    method: 'post',
    data: parameter
  })
}

/**
 * 关系挖掘_关系规则_详情
 * @param {Object} parameter
 */
export function relationRuleDetail(parameter) {
  return axios({
    url: '/relationRule/detail',
    method: 'get',
    params: parameter
  })
}

/**
 * 根据概念查询关系
 * @param {Object} parameter
 */
export function listByConcept(parameter) {
  return axios({
    url: '/relation/listByConcept',
    method: 'get',
    params: parameter
  })
}

/**
 * 根据概念查询关系
 * @param {boolean} schemaFrom
 * @param {Object} id
 */
export function listRelationOrSchema(schemaFrom, id) {
  const cmd = id ? '/relation/listByRelation' : '/schema/list'
  let params
  if (id) {
    if (schemaFrom) {
      params = {
        'schemaTo': id
      }
    } else {
      params = {
        'schemaFrom': id
      }
    }
  }
  return axios({
    url: cmd,
    method: 'get',
    params: params
  })
}

/**
 * 关系挖掘_关系规则_详情 关系接口
 * @param {Object} parameter
 * @param {Object} params
 */
export function relationRuleMerge(parameter, params) {
  return Promise.all([relationList(parameter), relationRuleDetail(params)])
    .then((result) => {
      const error = result.find((it) => !it.success)
      if (error) {
        return Promise.reject(Error('加载失败!'))
      } else {
        const relation = result[0]
        const relationRule = result[1]
        const useRelation = relation.data.find((it) => it.id === relationRule.data.relationId)
        if (useRelation) {
          return Promise.all([propertyPage({
            'schemaId': useRelation.schemaFrom
          }), propertyPage({
            'schemaId': useRelation.schemaTo
          })])
            .then((propertys) => {
              const e = propertys.find((it) => !it.success)
              if (e) {
                return Promise.reject(Error('加载失败!'))
              } else {
                return Promise.resolve({
                  relation: relation.data || {},
                  relationRule: Object.assign(relationRule.data, {
                    propertyAList: propertys[0].data.rows,
                    propertyBList: propertys[1].data.rows,
                    conceptAName: useRelation.schemaFromName,
                    conceptBName: useRelation.schemaToName
                  })
                })
              }
            })
        } else {
          return Promise.reject(Error('加载失败!'))
        }
      }
    })
    .catch((e) => {
      return Promise.reject(e)
    })
}
